{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "import cudaq\n",
    "from cudaq import spin\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "from torch.autograd import Function\n",
    "from torchvision import datasets, transforms\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "torch.manual_seed(22)\n",
    "cudaq.set_random_seed(44)\n",
    "\n",
    "# device = torch.device('cpu')\n",
    "# cudaq.set_target(\"qpp-cpu\")\n",
    "\n",
    "cudaq.set_target(\"nvidia\") # nvidia-mqpu\n",
    "device = torch.device(\"cuda\")\n",
    "\n",
    "print(cudaq.num_available_gpus())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(target_digits, sample_count, test_size):\n",
    "    \"\"\"Load and prepare the MNIST dataset to be used\n",
    "\n",
    "    Args:\n",
    "        target_digits (list): digits to perform classification of\n",
    "        sample_count (int): total number of images to be used\n",
    "        test_size (float): percentage of sample_count to be used as test set, the remainder is the training set\n",
    "\n",
    "    Returns:\n",
    "        dataset in train, test format with targets\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    transform = transforms.Compose(\n",
    "        [transforms.ToTensor(),\n",
    "         transforms.Normalize((0.1307), (0.3081))])\n",
    "\n",
    "    dataset = datasets.MNIST(\"./data\",\n",
    "                             train=True,\n",
    "                             download=True,\n",
    "                             transform=transform)\n",
    "\n",
    "    # Filter out the required labels.\n",
    "    idx = (dataset.targets == target_digits[0]) | (dataset.targets\n",
    "                                                   == target_digits[1])\n",
    "    dataset.data = dataset.data[idx]\n",
    "    dataset.targets = dataset.targets[idx]\n",
    "\n",
    "    # Select a subset based on number of datapoints specified by sample_count.\n",
    "    subset_indices = torch.randperm(dataset.data.size(0))[:sample_count]\n",
    "\n",
    "    x = dataset.data[subset_indices].float().unsqueeze(1).to(device)\n",
    "\n",
    "    y = dataset.targets[subset_indices].to(device).float().to(device)\n",
    "\n",
    "    # Relabel the targets as a 0 or a 1.\n",
    "    y = torch.where(y == min(target_digits), 0.0, 1.0)\n",
    "\n",
    "    x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                        y,\n",
    "                                                        test_size=test_size /\n",
    "                                                        100,\n",
    "                                                        shuffle=True,\n",
    "                                                        random_state=42)\n",
    "\n",
    "    return x_train, x_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "700\n"
     ]
    }
   ],
   "source": [
    "# Classical parameters.\n",
    "\n",
    "sample_count = 1000  # Total number of images to use.\n",
    "target_digits = [5, 6]  # Hand written digits to classify.\n",
    "test_size = 30  # Percentage of dataset to be used for testing.\n",
    "classification_threshold = 0.5  # Classification boundary used to measure accuracy.\n",
    "epochs = 1000  # Number of epochs to train for.\n",
    "\n",
    "# Quantum parmeters.\n",
    "\n",
    "qubit_count = 5\n",
    "hamiltonian = spin.z(0)  # Measurement operator.\n",
    "shift = torch.tensor(torch.pi / 2)  # Magnitude of parameter shift.\n",
    "\n",
    "x_train, x_test, y_train, y_test = prepare_data(target_digits, sample_count,\n",
    "                                                test_size)\n",
    "print(len(x_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot some images from the training set to visualise.\n",
    "if device != 'cpu':\n",
    "    sample_to_plot = x_train[:10].to(torch.device('cpu'))\n",
    "else:\n",
    "    sample_to_plot = x_train[:10]\n",
    "\n",
    "grid_img = torchvision.utils.make_grid(sample_to_plot,\n",
    "                                       nrow=5,\n",
    "                                       padding=3,\n",
    "                                       normalize=True)\n",
    "plt.imshow(grid_img.permute(1, 2, 0))\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ╭───────╮\n",
      "q0 : ┤ ry(0) ├\n",
      "     ├───────┤\n",
      "q1 : ┤ rx(0) ├\n",
      "     ╰───────╯\n",
      "\n",
      "     ╭───────╮╭───────╮          \n",
      "q0 : ┤ ry(0) ├┤ rx(0) ├──●───────\n",
      "     ├───────┤├───────┤╭─┴─╮     \n",
      "q1 : ┤ ry(0) ├┤ rx(0) ├┤ x ├──●──\n",
      "     ├───────┤├───────┤╰───╯╭─┴─╮\n",
      "q2 : ┤ ry(0) ├┤ rx(0) ├─────┤ x ├\n",
      "     ╰───────╯╰───────╯     ╰───╯\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class QuantumFunction(Function):\n",
    "    \"\"\"Allows the quantum circuit to input data, output expectation values\n",
    "    and calculate gradients of variational parameters via finite difference\"\"\"\n",
    "\n",
    "    def __init__(self, qubit_count: int, hamiltonian: cudaq.SpinOperator):\n",
    "        \"\"\"Define the quantum circuit in CUDA Quantum\"\"\"\n",
    "\n",
    "        @cudaq.kernel\n",
    "        def kernel(qubit_count: int, thetas: np.ndarray):\n",
    "\n",
    "            qubits = cudaq.qvector(qubit_count)\n",
    "            for i in range(qubit_count):\n",
    "                ry(thetas[2*i], qubits[i])\n",
    "                rx(thetas[2*i+1], qubits[i])\n",
    "            \n",
    "            for i in range(0, qubit_count-1):\n",
    "                cx(qubits[i], qubits[i+1])\n",
    "\n",
    "\n",
    "        self.kernel = kernel\n",
    "        self.qubit_count = qubit_count\n",
    "        self.hamiltonian = hamiltonian\n",
    "\n",
    "    def run(self, theta_vals: torch.tensor) -> torch.tensor:\n",
    "        \"\"\"Excetute the quantum circuit to output an expectation value\"\"\"\n",
    "\n",
    "        #If running on GPU, thetas is a torch.tensor that will live on GPU memory. The observe function calls a .tolist() method on inputs which moves thetas from GPU to CPU.\n",
    "\n",
    "        qubit_count = [self.qubit_count for _ in range(theta_vals.shape[0])]\n",
    "\n",
    "        results = cudaq.observe(self.kernel, self.hamiltonian, qubit_count,\n",
    "                                theta_vals)\n",
    "\n",
    "        exp_vals = [results[i].expectation() for i in range(len(results))]\n",
    "        exp_vals = torch.Tensor(exp_vals).to(device)\n",
    "\n",
    "        return exp_vals\n",
    "\n",
    "    @staticmethod\n",
    "    def forward(ctx, thetas: torch.tensor, quantum_circuit,\n",
    "                shift) -> torch.tensor:\n",
    "\n",
    "        # Save shift and quantum_circuit in context to use in backward.\n",
    "        ctx.shift = shift\n",
    "        ctx.quantum_circuit = quantum_circuit\n",
    "\n",
    "        # Calculate expectation value.\n",
    "        exp_vals = ctx.quantum_circuit.run(thetas).reshape(-1, 1)\n",
    "\n",
    "        ctx.save_for_backward(thetas, exp_vals)\n",
    "\n",
    "        return exp_vals\n",
    "\n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        \"\"\"Backward pass computation via finite difference\"\"\"\n",
    "\n",
    "        thetas, _ = ctx.saved_tensors\n",
    "\n",
    "        gradients = torch.zeros(thetas.shape, device=device)\n",
    "\n",
    "        for i in range(thetas.shape[1]):\n",
    "\n",
    "            thetas_plus = thetas.clone()\n",
    "            thetas_plus[:, i] += ctx.shift\n",
    "            exp_vals_plus = ctx.quantum_circuit.run(thetas_plus)\n",
    "\n",
    "            thetas_minus = thetas.clone()\n",
    "            thetas_minus[:, i] -= ctx.shift\n",
    "            exp_vals_minus = ctx.quantum_circuit.run(thetas_minus)\n",
    "\n",
    "            gradients[:, i] = (exp_vals_plus - exp_vals_minus) / (2 * ctx.shift)\n",
    "\n",
    "        gradients = torch.mul(grad_output, gradients)\n",
    "\n",
    "        return gradients, None, None\n",
    "\n",
    "\n",
    "@cudaq.kernel\n",
    "def test_kernel(qubit_count: int, thetas: np.ndarray):\n",
    "\n",
    "    qubits = cudaq.qvector(qubit_count)\n",
    "\n",
    "    ry(thetas[0], qubits[0])\n",
    "    rx(thetas[1], qubits[1])\n",
    "print(cudaq.draw(test_kernel, 2, np.zeros(2)))\n",
    "\n",
    "@cudaq.kernel\n",
    "def test_kernel(qubit_count: int, thetas: np.ndarray):\n",
    "\n",
    "    qubits = cudaq.qvector(qubit_count)\n",
    "    for i in range(qubit_count):\n",
    "        ry(thetas[2*i], qubits[i])\n",
    "        rx(thetas[2*i+1], qubits[i])\n",
    "    for i in range(0, qubit_count-1):\n",
    "        cx(qubits[i], qubits[i+1])\n",
    "\n",
    "print(cudaq.draw(test_kernel, 3, np.zeros(6)))\n",
    "\n",
    "# Refer @staticmethod: https://ji3g4zo6qi6.medium.com/python-tips-5d36df9f6ad5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumLayer(nn.Module):\n",
    "    \"\"\"Encapsulates a quantum circuit into a quantum layer adhering PyTorch convention\"\"\"\n",
    "\n",
    "    def __init__(self, qubit_count: int, hamiltonian, shift: torch.tensor):\n",
    "        super(QuantumLayer, self).__init__()\n",
    "\n",
    "        self.quantum_circuit = QuantumFunction(qubit_count, hamiltonian)\n",
    "        self.shift = shift\n",
    "\n",
    "    def forward(self, input):\n",
    "\n",
    "        result = QuantumFunction.apply(input, self.quantum_circuit, self.shift)\n",
    "\n",
    "        return result\n",
    "    \n",
    "class Hybrid_QNN(nn.Module):\n",
    "    \"\"\"Structure of the hybrid neural network with classical fully connected layers and quantum layers\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Hybrid_QNN, self).__init__()\n",
    "\n",
    "        self.fc1 = nn.Linear(28 * 28, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.dropout = nn.Dropout(0.25)\n",
    "\n",
    "        self.fc3 = nn.Linear(128, 64)\n",
    "        self.fc4 = nn.Linear(64, 32)\n",
    "        self.fc5 = nn.Linear(32, 2**qubit_count)\n",
    "        self.dropout = nn.Dropout(0.25)\n",
    "\n",
    "        # The 2 outputs from PyTorch fc5 layer feed into the 2 variational gates in the quantum circuit.\n",
    "        self.quantum = QuantumLayer(qubit_count, hamiltonian, shift)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        x = x.view(-1, 28 * 28)  # Turns images into vectors.\n",
    "\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        x = self.dropout(x)\n",
    "\n",
    "        x = torch.relu(self.fc3(x))\n",
    "        x = torch.relu(self.fc4(x))\n",
    "        x = torch.relu(self.fc5(x))\n",
    "        x = self.dropout(x)\n",
    "\n",
    "        # Quantum circuit outputs an expectation value which is fed into the sigmoid activation function to perform classification.\n",
    "        x = torch.sigmoid(self.quantum(x))\n",
    "\n",
    "        return x.view(-1)\n",
    "\n",
    "def accuracy_score(y, y_hat):\n",
    "    return sum((y == (y_hat >= classification_threshold))) / len(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 24%|██▍       | 24/100 [2:15:11<7:08:05, 337.97s/it]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[25], line 41\u001b[0m\n\u001b[1;32m     37\u001b[0m y_hat_train \u001b[38;5;241m=\u001b[39m hybrid_model(x_batch)\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[1;32m     39\u001b[0m train_cost \u001b[38;5;241m=\u001b[39m loss_function(y_hat_train, y_batch)\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[0;32m---> 41\u001b[0m \u001b[43mtrain_cost\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     42\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mstep()\n\u001b[1;32m     44\u001b[0m epoch_train_cost \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m train_cost\u001b[38;5;241m.\u001b[39mitem()\n",
      "File \u001b[0;32m~/.conda/envs/cuda-quantum/lib/python3.10/site-packages/torch/_tensor.py:522\u001b[0m, in \u001b[0;36mTensor.backward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m    512\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m    513\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[1;32m    514\u001b[0m         Tensor\u001b[38;5;241m.\u001b[39mbackward,\n\u001b[1;32m    515\u001b[0m         (\u001b[38;5;28mself\u001b[39m,),\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    520\u001b[0m         inputs\u001b[38;5;241m=\u001b[39minputs,\n\u001b[1;32m    521\u001b[0m     )\n\u001b[0;32m--> 522\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautograd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    523\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs\u001b[49m\n\u001b[1;32m    524\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/.conda/envs/cuda-quantum/lib/python3.10/site-packages/torch/autograd/__init__.py:266\u001b[0m, in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m    261\u001b[0m     retain_graph \u001b[38;5;241m=\u001b[39m create_graph\n\u001b[1;32m    263\u001b[0m \u001b[38;5;66;03m# The reason we repeat the same comment below is that\u001b[39;00m\n\u001b[1;32m    264\u001b[0m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[1;32m    265\u001b[0m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[0;32m--> 266\u001b[0m \u001b[43mVariable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[1;32m    267\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    268\u001b[0m \u001b[43m    \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    269\u001b[0m \u001b[43m    \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    270\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    271\u001b[0m \u001b[43m    \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    272\u001b[0m \u001b[43m    \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    273\u001b[0m \u001b[43m    \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    274\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "\n",
    "\n",
    "batch_size = 32  # 可調整的batch size\n",
    "\n",
    "# 創建訓練和測試數據集\n",
    "train_dataset = TensorDataset(x_train, y_train)\n",
    "test_dataset = TensorDataset(x_test, y_test)\n",
    "\n",
    "# 創建數據加載器\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "hybrid_model = Hybrid_QNN().to(device)\n",
    "\n",
    "optimizer = optim.Adadelta(hybrid_model.parameters(), lr=0.001, weight_decay=0.8)\n",
    "\n",
    "loss_function = nn.BCELoss().to(device)\n",
    "\n",
    "training_cost = []\n",
    "testing_cost = []\n",
    "training_accuracy = []\n",
    "testing_accuracy = []\n",
    "\n",
    "for epoch in tqdm(range(100)):\n",
    "    hybrid_model.train()\n",
    "    epoch_train_cost = 0\n",
    "    correct_train = 0\n",
    "    total_train = 0\n",
    "\n",
    "    for x_batch, y_batch in train_loader:\n",
    "        x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        y_hat_train = hybrid_model(x_batch).to(device)\n",
    "\n",
    "        train_cost = loss_function(y_hat_train, y_batch).to(device)\n",
    "\n",
    "        train_cost.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        epoch_train_cost += train_cost.item()\n",
    "        correct_train += (y_hat_train.round() == y_batch).sum().item()\n",
    "        total_train += y_batch.size(0)\n",
    "\n",
    "    training_accuracy.append(correct_train / total_train)\n",
    "    training_cost.append(epoch_train_cost / len(train_loader))\n",
    "\n",
    "    hybrid_model.eval()\n",
    "    epoch_test_cost = 0\n",
    "    correct_test = 0\n",
    "    total_test = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for x_batch, y_batch in test_loader:\n",
    "            x_batch, y_batch = x_batch.to(device), y_batch.to(device)\n",
    "\n",
    "            y_hat_test = hybrid_model(x_batch).to(device)\n",
    "\n",
    "            test_cost = loss_function(y_hat_test, y_batch).to(device)\n",
    "\n",
    "            epoch_test_cost += test_cost.item()\n",
    "            correct_test += (y_hat_test.round() == y_batch).sum().item()\n",
    "            total_test += y_batch.size(0)\n",
    "\n",
    "    testing_accuracy.append(correct_test / total_test)\n",
    "    testing_cost.append(epoch_test_cost / len(test_loader))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██        | 4/20 [05:42<22:38, 84.90s/it]"
     ]
    }
   ],
   "source": [
    "# from tqdm import tqdm\n",
    "\n",
    "# hybrid_model = Hybrid_QNN().to(device)\n",
    "\n",
    "# optimizer = optim.Adadelta(hybrid_model.parameters(),\n",
    "#                            lr=0.001,\n",
    "#                            weight_decay=0.8)\n",
    "\n",
    "# loss_function = nn.BCELoss().to(device)\n",
    "\n",
    "# training_cost = []\n",
    "# testing_cost = []\n",
    "# training_accuracy = []\n",
    "# testing_accuracy = []\n",
    "\n",
    "# hybrid_model.train()\n",
    "# for epoch in tqdm(range(20)):\n",
    "\n",
    "#     optimizer.zero_grad()\n",
    "\n",
    "#     y_hat_train = hybrid_model(x_train).to(device)\n",
    "\n",
    "#     train_cost = loss_function(y_hat_train, y_train).to(device)\n",
    "\n",
    "#     train_cost.backward()\n",
    "\n",
    "#     optimizer.step()\n",
    "\n",
    "#     training_accuracy.append(accuracy_score(y_train, y_hat_train))\n",
    "#     training_cost.append(train_cost.item())\n",
    "\n",
    "#     hybrid_model.eval()\n",
    "#     with torch.no_grad():\n",
    "\n",
    "#         y_hat_test = hybrid_model(x_test).to(device)\n",
    "\n",
    "#         test_cost = loss_function(y_hat_test, y_test).to(device)\n",
    "\n",
    "#         testing_accuracy.append(accuracy_score(y_test, y_hat_test))\n",
    "#         testing_cost.append(test_cost.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "training_accuracy = [x for x in training_accuracy]\n",
    "testing_accuracy = [x for x in testing_accuracy]\n",
    "\n",
    "plt.figure(figsize=(10, 5))\n",
    "\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(training_cost, label='Train')\n",
    "plt.plot(testing_cost, label='Test')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Cost')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(training_accuracy, label='Train')\n",
    "plt.plot(testing_accuracy, label='Test')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor(0.5229),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171),\n",
       " tensor(0.5171)]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "training_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(cudaq.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "qmg",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
